import java.util.Scanner;

/**
   作者:TC
   时间:${DATA} 20:59
   描述:没有bug
*/// 按两次 Shift 打开“随处搜索”对话框并输入 `show whitespaces`，
// 然后按 Enter 键。现在，您可以在代码中看到空格字符。
//public String getName() {
//        return name;
//        }
//
//public void setName(String name) {
//        this.name = name;
//        }
//
//public int getNum() {
//        return num;
//        }
//
//public void setNum(int num) {
//        this.num = num;
//        }
//
//public int getPunish() {
//        return punish;
//        }
//
//public void setPunish(int punish) {
//        this.punish = punish;
//        }
public class Main {
    //定义一个Team类
    public static class Team{
        String name;
        int num;
        int punish;

        public Team(String name, int num, int punish) {
            this.name = name;
            this.num = num;
            this.punish = punish;
        }
    }
    //创建堆 推排序

    public static void main(String[] args) {
        int N;
        String Tname;
        int num,punish;
        System.out.println("请输入队伍的数量");
        Scanner Sc=new Scanner(System.in);
        N=Sc.nextInt();
        //new一个对象数组
        Team[] T = new Team[N];
        for (int i = 0; i < N; i++) {
            System.out.println("请输入队伍的名称,得分，罚时间：");
            Tname = Sc.next();
//            System.out.println("请输入得分");
            num = Sc.nextInt();
//            System.out.println("请输入罚时");
            punish = Sc.nextInt();
            T[i] = new Team(Tname, num, punish);
        }
        //对于每一个队伍进行堆排序定义一个堆排序的方法
        //构建一个方法进行交换两个相邻节点的大小
        // 输出每一个队伍的信息
        for(int i=0;i<T.length;i++)
        {
            System.out.println("第"+(i+1)+"队伍："+" name:"+T[i].name+" num:"+T[i].num+" punish:"+T[i].punish);
        }
        HeapSort(T);
        System.out.println("堆排序后的结果为");
        for(int i=0;i<T.length;i++)
        {
            System.out.println("第"+(i+1)+"名："+" name:"+T[i].name+" num:"+T[i].num+" punish:"+T[i].punish);
        }
        System.out.println("\n");
    }
    //进行堆排序操作
    public static void HeapSort(Team[] a){
        int n=a.length;
        adjustHeap(a);
        for(int i=n-1;i>0;i--)
        {
            //依次交换堆顶元素以及最后一个元素
            swapnode(a,0,i);
            //每一次进行下沉操作
            headTree(a,0,i);
        }
    }
    //进行建最大堆
    public static void adjustHeap(Team[] a){
       int n=a.length;
        for(int i=n/2-1;i>=0;i--){
            //对于每一个节点依次进行下沉操作
            headTree(a,i,n);
        }
    }

    //将堆进行下沉操作 分别进行三种操作，i,i+1,i+2,进行交换最大的largest 使双亲结点大于孩子节点
    public static void headTree(Team[] a,int i, int size)
    {
      int largest=i;
      int left=2*i+1;
      int right=2*i+2;
      if(left<size&&CompareTeam(a[left],a[largest])>0)
      {
          largest=left;
      }
      if(right<size&&CompareTeam(a[right],a[largest])>0)
      {
          largest=right;
      }
      if(largest!=i){
          swapnode(a,i,largest);
          //递归进行
          headTree(a,largest,size);
      }
    }
    //构建一个函数返回两个队伍比较后的大小返回得分与乘法时间之差 分开讨论三种情况 两者的得分相同时，惩罚时间是否相同 以及
    //以及按照队伍的名称来进行排序
    public static int CompareTeam(Team a,Team b)
    {
        if(a.num!=b.num)
        {
            return a.num-b.num;
        }
        else if(a.punish!=b.punish){
            return a.punish-b.punish;
        }else{
            //根据名字的字符顺序来计较队伍的顺序
            return a.name.compareTo(b.name);
        }
    }
    //构建一个静态方法进行交换两个相邻节点的大小
    public static void  swapnode(Team[] T,int i,int j)
    {
       Team team=T [i];
       T[i]=T[j];
       T[j]=team;
    }
}